package ongd.servicios.persistencia;

import java.io.Serializable;
import javax.persistence.EntityManager;
import javax.persistence.EntityNotFoundException;
import ongd.negocio.gestion.Configuracion;
import ongd.negocio.gestion.Entidad;
import ongd.servicios.persistencia.exceptions.NonexistentEntityException;
import ongd.servicios.persistencia.exceptions.PreexistingEntityException;

/**
 * Clase que contiene los método que para realizar operaciones
 * sobre la base de datos referente a la entidad Configuracion.
 *
 * @author <a href="mailto:egi0002@alu.ubu.es">Elena García Iglesias</a>
 * @author <a href="mailto:cms0021@alu.ubu.es">Cristina Martínez Sanz</a>
 * @version 1.0 20120124
 *
 */
public class ConfiguracionJpaController extends AJPAControlador implements Serializable {

    /**
     * Objeto de tipo EntityManager.
     */
    private EntityManager em = null;

    /**
     * Constructor de la clase.
     * @param em EntityManager
     */
    public ConfiguracionJpaController(EntityManager em) {
        this.em = em;
    }

    /**
     * Método que crea un objeto de tipo configuracion en la base de datos.
     * @param entidad Objeto que crearemos 
     * @param et Booleano que indica si hay que iniciar la transacción
     * @throws PreexistingEntityException
     * @throws Exception 
     */
    @Override
    public void create(Entidad entidad, boolean et) throws PreexistingEntityException, Exception {
        Configuracion configuracion = (Configuracion) entidad;
        try {
            //Si et es falso significa que tengo que crear la transacción
            if (!et) {
                em.getTransaction().begin();
            }
            em.persist(configuracion);
            //Si et es falso significa que tengo que terminar la transaccion
            if (!et) {
                em.getTransaction().commit();
            }
        } catch (Exception ex) {
            if (findEntidad(Configuracion.class, configuracion.getIdconfiguracion()) != null) {
                throw new PreexistingEntityException("Configuracion " + configuracion + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
//                em.close();
            }
        }
    }

    /**
     * Método que edita un objeto de tipo configuración en la base de datos.
     * @param entidad Entidad que editaremos
     * @param et Booleano que indica si hay que iniciar la transacción
     * @throws NonexistentEntityException
     * @throws Exception 
     */
    @Override
    public void edit(Entidad entidad, boolean et) throws NonexistentEntityException, Exception {
        Configuracion configuracion = (Configuracion) entidad;
        try {
            //Si et es falso significa que tengo que crear la transacción
            if (!et) {
                em.getTransaction().begin();
            }
            configuracion = em.merge(configuracion);
            //Si et es falso significa que tengo que terminar la transaccion
            if (!et) {
                em.getTransaction().commit();
            }
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = configuracion.getIdconfiguracion();
                if (findEntidad(Configuracion.class, id) == null) {
                    throw new NonexistentEntityException("The configuracion with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
//                em.close();
            }
        }
    }

    /**
     * Método que borra un objeto de tipo configuracion de la base de datos.
     * @param clase Clase correpondiente al objeto a borrar
     * @param id Clave primaria del objeto a borrar
     * @param et Booleano que indica si hay que iniciar la transaccion
     * @throws NonexistentEntityException 
     */
    @Override
    public void destroy(Class clase, Object id, boolean et) throws NonexistentEntityException {
        try {
            //Si et es falso significa que tengo que crear la transacción
            if (!et) {
                em.getTransaction().begin();
            }
            Configuracion configuracion;
            try {
                configuracion = (Configuracion) em.getReference(clase, id);
                configuracion.getIdconfiguracion();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The configuracion with id " + id + " no longer exists.", enfe);
            }
            em.remove(configuracion);
            //Si et es falso significa que tengo que terminar la transaccion
            if (!et) {
                em.getTransaction().commit();
            }
        } finally {
            if (em != null) {
//                em.close();
            }
        }
    }

    /**
     * Método que busca una configuración en la base de datos.
     * @param cls Class correspondiente al objeto a buscar
     * @param id Clave primaria del objeto a buscar
     * @return configuracion
     */
    @Override
    public Configuracion findEntidad(Class cls, Object id) {
        try {
            return (Configuracion) em.find(cls, id);
        } finally {
//            em.close();
        }
    }
}
